
#include <bits/stdc++.h>
#include<string>
#include<fstream>
using namespace std;

FILE* file = fopen("output.txt", "w");

const int n = 200;
const int robot_num = 10;
const int berth_num = 10;
const int N = 210;
const int boat_num = 5;

struct Robot
{
    int x, y, goods;
    int status;
    int mbx, mby;
    Robot() {}
    Robot(int startX, int startY) {
        x = startX;
        y = startY;
    }
}robot[robot_num + 10];

struct Berth
{
    int x;
    int y;
    int transport_time;
    int loading_speed;
    Berth() {}
    Berth(int x, int y, int transport_time, int loading_speed) {
        this->x = x;
        this->y = y;
        this->transport_time = transport_time;
        this->loading_speed = loading_speed;
    }
}berth[berth_num + 10];

struct Boat
{
    int num, pos, status;//货物数量、所在泊点编号、状态
}boat[boat_num+10];

int money, boat_capacity, id;//金额，船的容积，当前帧数
int cnt = 0;//当前地图上出现过的货物数量
char ch[N][N];//地图
char rb[N][N];//记录机器人的位置A
char hd[N][N];//货物刷新时的帧数，hd[x][y]=100表示货物在100帧时，于(x,y)处刷新

void Init()
{
    //读入地图200行(从ch[0][0]开始存比较合适)
    for (int i = 0; i < n; i++)
        scanf("%s", ch[i] );
    //读入泊位信息
    for (int i = 0; i < berth_num; i++)
    {
        int id;
        scanf("%d", &id);
        scanf("%d%d%d%d", &berth[id].x, &berth[id].y, &berth[id].transport_time, &berth[id].loading_speed);
    }
    //读入船舶容量
    scanf("%d", &boat_capacity);
    char okk[100];
    //读入OK，初始化信息发送完毕
    scanf("%s", okk);

    //输出OK，表示初始化信息接收完成
    printf("OK\n");
    fflush(stdout);
}


//dfs时，是否访问
char vis[210][210];
int dx[4] = { 0,0,-1,1 };//0~3对应的方向变化
int dy[4] = { 1,-1,0,0 };


int bercnt[berth_num];//记录泊点当前堆积了多少货物 （在每一个task完成后，加1）
int taskboat[boat_num];//当前船是否有任务在身 (在每一帧的船舶指令前，依据船舶状态设置)
int taskbert[10];//当前泊点是否有船要过来 （在寻找船舶时置1，在船舶开走时置0）
int berboat[10];//当前泊点停靠的船的编号，没有则为-1（在input中，依据船舶状态设置）

const int mynum = 5000;//任务队列要开多大？
int rob_task[robot_num];//i号机器人负责的任务编号，没有则为-1

int steped[robot_num + mynum];//'寻物'已经走了几步
int pcnt[robot_num + mynum];//路径长度（帧）

int steped3[robot_num + mynum]; //'寻泊'已经走了几步
int pcnt3[robot_num + mynum];//路径长度


int Input()
{

    //读入帧和金额
    scanf("%d%d", &id, &money);
    int num;
    //读入新增货物数量
    scanf("%d", &num);
    //读入新增货物信息
    for (int i = 1; i <= num; i++)
    {
        int x, y, val;
        scanf("%d%d%d", &x, &y, &val);

        if (ch[x][y] == '*' || ch[x][y] == '#')//假设货物有可能生成在障碍物上，那么需要舍弃
            continue;

        {
            //xrr[++cnt] = x;//记录货物信息x
            //yrr[cnt] = y;//记录货物信息y
            //vrr[cnt] = val;//记录货物信息val
        }
       
      
        hd[x][y] = '1'; //记录货物出现的时刻与位置

    }
    //读入10个机器人的状态
    for (int i = 0; i < robot_num; i++)
    {
       

        if (id != 1) rb[robot[i].x][robot[i].y] = '.';//位置释放
       
        scanf("%d%d%d%d", &robot[i].goods, &robot[i].x, &robot[i].y, &robot[i].status);
        if (id == 1) {
            ch[robot[i].x][robot[i].y] = '.';  
        }
        rb[robot[i].x][robot[i].y] = 'A';


        
    }
    //读入船舶状态
    for (int i = 0; i < 5; i++) {
        scanf("%d%d\n", &boat[i].status, &boat[i].pos);
        if (boat[i].status!=0&&boat[i].pos != -1) {//如果当前船停靠于泊点
            berboat[boat[i].pos] = i;//记录下来
        }
    }
        
    char okk[100];
    //读入OK，当前帧信息获取完毕
    scanf("%s", okk);
    return id;
}





int robcnt = 0; // 正在工作的机器人数目(只会增加，不会减少)


//===============寻找货物-方案1
//朴素的dfs，得到的结果路径太长,pass掉~，但是可以在dfs过程中限制一下ph.size()<1000

const int maxlen_2 = 100;//能接受的最长路径长度

string path2[robot_num+mynum];//记录每个“正在执行任务的”机器人的“寻货路径”

int robi;//接受任务的机器人编号
int hx, hy;//目标货物位置


int flag = 0; // 是否找到路径（是否到达货物）
//不需要指定货物，在dfs的过程中，遇到货物就行。
//需要提前在地图上标注货物的位置
void dfs2(int rx, int ry, string ph) {
    if (ph.size() > maxlen_2)//路径太长直接舍弃,路径长度大于1000的解没有意义，因为货物只存在1000帧（考虑到跳帧，这个数值最好再减小一点）
        return;

    if (flag == 1) {//已经找到路了，不用再走了
        return;
    }


    //到达目标
    if (hd[rx][ry] == '1') {

        //besign[rx][ry] = 1;//该货物已经被锁定了
        hd[rx][ry] = '0';
       
        path2[robcnt] = ph;
        pcnt[robcnt] = ph.size();
        hx = rx; hy = ry;
        flag = 1;
        return;
        
    }

    if (vis[rx][ry] == '1') {//访问过了
        return;
    }
 
    vis[rx][ry] = '1';

    if (ch[rx][ry] == '*' || ch[rx][ry] == '#' || (rb[rx][ry] == 'A' && ph != "")) {//走不通(ps:若dfs到了其它机器人，那么这个方向就不用再试探了？)

        return;
    }


    if (rx - 1 >= 0) {
        dfs2(rx - 1, ry, ph+"2");//2
    }
    if (ry - 1 >= 0) {
        dfs2(rx, ry - 1, ph+"1");//1
    }

    if (rx + 1 <= (n - 1)) {
        dfs2(rx + 1, ry, ph+"3");//3
    }
    if (ry + 1 <= (n - 1))
    {
        dfs2(rx, ry + 1, ph+"0");//0
    }
}

struct Node
{
    Node(int ax,int ay,int adep,string aph):x(ax),y(ay),dep(adep),ph(aph){}
    int x;
    int y;
    int dep;
    string ph;
};

#include<queue>
queue<Node> nq;//搜索队列
int maxdep_2 = 100;//搜索的最大深度


void bfs2(int rx, int ry) {
    
    queue<Node>().swap(nq);

    nq.push(Node(rx, ry, 0,""));
    vis[rx][ry] = '1';//已访问
    while (nq.size() > 0) {
        Node t = nq.front();
        nq.pop();
        if (t.dep > maxdep_2)return;//开销太大，舍弃

        for (int i = 0; i < 4; ++i) {
            int nx = t.x + dx[i]; int ny = t.y + dy[i];
            if (nx >= 0 && nx <= (n - 1) && ny >= 0 && ny <= (n - 1)) {
                if (hd[nx][ny] == '1') {//找到目标
                    hd[nx][ny] = '0';
                    path2[robcnt] = t.ph + char(i + '0');
                    pcnt[robcnt] = path2[robcnt].size();
                    hx = nx; hy = ny;//货物坐标
                    flag = 1;
                    return;
                }

                if (ch[nx][ny] == '*' || ch[nx][ny] == '#' || vis[nx][ny] == '1' || rb[nx][ny] == 'A') {//此路不通，换一个
                    continue;
                }

                vis[nx][ny] = '1';//已访问
                if (t.dep + 1 > maxdep_2)continue;
                //if (nq.size() >= 177)return;
                nq.push(Node(nx, ny, t.dep + 1, t.ph + char(i + '0')));
            }
        
        }

    }

}


//==============寻找泊点

string path3[robot_num+mynum];

int flag3 = 0;//是否找到泊点（是否到达泊点）
int bx, by;//目标泊点坐标

int bid[robot_num+mynum];//目标泊点编号(应该可以删去)
int maxlen_3 = 600;
void dfs3(int rx, int ry, string ph) {
    if (ph.size() >= maxlen_3) {//虽然没有时限，但路径长度还是少点好
        return;
    }

    if (flag3 == 1) {//已经找到路了，不用再走了
        return;
    }

    //到达目标
    if (ch[rx][ry] == 'B') {
        //cout << ph << endl;
        //cout << ph.size() << endl;
    
        path3[robcnt] = ph;
        pcnt3[robcnt] = ph.size();
       // bx[robcnt] = rx;
        //by[robcnt] = ry;
        bx = rx;
        by = ry;
        flag3 = 1;
        return;
        
    }

    if (vis[rx][ry] == '1') {//访问过了
        return;
    }
    vis[rx][ry] = '1';

    if (ch[rx][ry] == '*' || ch[rx][ry] == '#' || rb[rx][ry] == 'A') {
        return;
    }
    {
        if (ry + 1 <= (n - 1))
        {
            dfs3(rx, ry + 1, ph + "0");//0
        }
        if (rx - 1 >= 0) {
            dfs3(rx - 1, ry, ph + "2");//2
        }
        if (ry - 1 >= 0) {
            dfs3(rx, ry - 1, ph + "1");//1
        }

        if (rx + 1 <= (n - 1)) {

            dfs3(rx + 1, ry, ph + "3");//3
        }
       
    }


}

int maxdep_3 = 110;//最大深度
void bfs3(int rx, int ry) {
    //初始化
    memset(vis, '0', sizeof(vis));
    queue<Node>().swap(nq);

    nq.push(Node(rx, ry, 0,""));
    vis[rx][ry] = '1';//已访问
    while (nq.size() > 0) {
        
        Node t = nq.front();


        nq.pop();
        if (t.dep > maxdep_3)return;//开销太大，舍弃

        for (int i = 0; i < 4; ++i) {
            int nx = t.x + dx[i]; int ny = t.y + dy[i];
            if (nx >= 0 && nx <= (n - 1) && ny >= 0 && ny <= (n - 1)) {
                if (ch[nx][ny] == 'B' && rb[nx][ny] != 'A') {//搜索到码头，且没有机器人占用
                //fbfs[nx][ny] = i;
                //path3[robcnt] = getpath(nx, ny);
                    path3[robcnt] = t.ph + char(i + '0');
                    pcnt3[robcnt] = path3[robcnt].size();
                    bx = nx; by = ny;//泊点坐标
                    flag3 = 1;
                    return;
                }

                if (ch[nx][ny] == '*' || ch[nx][ny] == '#' || vis[nx][ny] == '1' || rb[nx][ny] == 'A') {//此路不通，换一个
                    continue;
                }

                vis[nx][ny] = '1';//已访问
                if (t.dep + 1 > maxdep_3)continue;
                //if (nq.size() >= 177)return;

                nq.push(Node(nx, ny, t.dep + 1, t.ph + char(i + '0')));
            }

            
        }

    }
}


int boating[mynum];//正在工作的船


int robing[robot_num+mynum];//robing[3]=6;正在执行3号任务的机器人编号为6

void solve() {//新增任务
    for (int i = 0; i < robot_num; ++i) {
        if (id < 500) {
            //fprintf(file, "机器人 %d , rob_task %d , robot.status %d\n", i, rob_task[i], robot[i].status);
        }
        if (id > 1000) {
           //fprintf(file, "机器人 %d , rob_task %d , robot.status %d\n", i,rob_task[i],robot[i].status);
            //fprintf(file, "机器人坐标 (%d,%d)\n", robot[i].x, robot[i].y);
        }
        {
            if (rob_task[i] != -1)continue;//该机器人有任务在身
            if (robot[i].status == 0)continue;//该机器人处于恢复状态
        }


        flag = 0; flag3 = 0;
        memset(vis, '0', sizeof(vis));
       
        bfs2(robot[i].x, robot[i].y);
        if (id > 1000)fprintf(file, "bfs2结束\n");
        if (flag == 1) {
            if ( id < 5100) {
                fprintf(file, "bfs2成功\n");
            }
            
            //memset(fbfs, -1, sizeof(fbfs));
            //dfs3(hx, hy, "");//机器人到泊点的路径
            bfs3(hx, hy);

            if (flag3 == 1) {
                if (id < 5100) {
                    fprintf(file, "bfs3成功\n");
                }
                

                for (int index = 0; index < berth_num; ++index) {//确认目标泊点的编号bid
                    if (berth[index].x <= bx && bx <= berth[index].x + 3 && berth[index].y <= by && by <= berth[index].y + 3) {
                        bid[robcnt] = index;
                        robot[i].mbx = hx;//记录目标货物坐标
                        robot[i].mby = hy;
                        break;
                    }
                }
                robing[robcnt] = i;//新增一个任务,由i号机器人负责(此时path2[robcnt]与path3[robcnt]都存有路径)
                rob_task[i] = robcnt;
                robcnt=robcnt+1;
                return;
            }
            if (id > 5000 && id < 5100) {
                fprintf(file, "bfs3失败\n");
            }
           
        }
        if (id > 5000 && id < 5100) {
            fprintf(file, "bfs2失败\n");
        }
        
    }


   
   
}





int block_time[robot_num + mynum];//记录任务i‘连续’堵塞的时间
int reach_fps[boat_num];//船到达泊点的时刻

int main()
{
    //test_dfs();
    
    
    if (file == nullptr) {
        perror("fopen failed");
        return 1;
    }



    
    Init();
    memset(berboat, -1, sizeof(berboat));//初始化
    memset(rob_task, -1, sizeof(rob_task));
    memset(taskbert, -1, sizeof(taskbert));
    memset(reach_fps, -1, sizeof(reach_fps));
    for (int zhen = 1; zhen <= 15000; ++zhen)
    {
        int id = Input();
        fprintf(file, "\n**in fps: %d**\n", id);
     
            //=====处理信息
            if (id > 10 ) {//多久新增一个数据
                solve();//尝试新增一个任务
                if (flag == 1 && flag3 == 1) {
                   // fprintf(file, "\n**add new task in fps %d ,now has %d tasks**\n", id, robcnt);
                   // fprintf(file, "\n**robot number: %d berth number: %d**\n", robing[robcnt - 1],bid[robcnt-1]);
                }

                flag = 0; flag3 = 0;//重置寻货flag和寻泊点flag

            }//ps:假设每次solve必定会获得一条路径,且没有考虑“机器人和货物一起被困在死胡同里的情况”


            //======输出机器人指令

            {//遍历任务列表
                for (int i = 0; i < robcnt; ++i) {//ps:通过step[i]和step3[i]的值，就自动过滤掉已完成的任务了
                    int robot_index = robing[i];//执行当前任务的机器人编号

                    if (robing[i] == -1)continue;//任务结束，跳过
                    if (robot[robot_index].status == 0)continue;//机器人瘫痪，跳过

                    fprintf(file, "in robcnt: %d\n", i);
                    
                    if (steped[i] == pcnt[i]) {//机器人在上一帧已经拿到货物
                        {//add 判断是否get到货物
                            if (robot[robot_index].goods == 1)
                                steped[i]++;//不用再“寻货”了
                            else {
                                //没有成功get到货物
                                if (hd[robot[robot_index].mbx][robot[robot_index].mby] == '1') {//正巧此时刷新了货物
                                    printf("get %d\n", robot_index);//拿取货物
                                    fprintf(file, "get %d\n", robot_index);
                                    hd[robot[robot_index].mbx][robot[robot_index].mby] = '0';//已经没有货物了
                                }
                                else {
                                    //任务中止
                                    robing[i] = -1;
                                    rob_task[robot_index] = -1;
                                    hd[robot[robot_index].mbx][robot[robot_index].mby] = '0';//已经没有货物了
                                    fprintf(file, "任务中止 %d\n", i);
                                    continue;

                                }
                            }
                        }
                    }
                    else if (steped[i] < pcnt[i]) {//机器人要去拿货物

            

                        int direc = path2[i][steped[i]] - '0';//移动方向
                        
                        int mx = robot[robot_index].x + dx[direc];//目标x坐标
                        int my = robot[robot_index].y + dy[direc];//目标y坐标
                        int ox = robot[robot_index].x;//当前x坐标
                        int oy = robot[robot_index].y;
                        if (rb[mx][my]=='A') {//判断是否与前面的任务存在碰撞
                            block_time[i]++;//阻塞计数+1
                            if (block_time[i] > 5) {
                                //任务中断
                                robing[i] = -1;
                                rob_task[robot_index] = -1;//这个不能忘记
                                fprintf(file, "任务中断 pull %d\n", robot_index);
                                hd[robot[robot_index].mbx][robot[robot_index].mby] = '1';//货物解除锁定
                            }
                            continue;
                        }
                        else {
                            block_time[i] = 0;//阻塞计数重置
                            printf("move %d %d\n", robot_index, direc);
                            //fprintf(file, "move %d %d\n", robot_index, direc);
                          

                            rb[mx][my]='A';//预更新地图
                
                            steped[i]++;//下一步
                            if (steped[i] == pcnt[i]) {
                                printf("get %d\n", robot_index);//拿起货物
                                fprintf(file, "get %d\n", robot_index);

                            }
                        }
                       
                    }

                    if (steped[i] > pcnt[i] && steped3[i] <= pcnt3[i]) {//机器人已经拿到货物，要去往泊点
                        if (steped3[i] == pcnt3[i]) {
                            printf("pull %d\n", robot_index);//放下货物
                            fprintf(file, "pull %d\n", robot_index);
                           
                            steped3[i]++;//已到达泊点

                            //任务结束
                            robing[i] = -1;//当前任务完成了
                            rob_task[robot_index] = -1;//机器人空闲
                            bercnt[bid[i]]++;//泊点货物+1
                            fprintf(file, "任务完成 %d\n", i);
      
                        }
                        else {
                            int direc = path3[i][steped3[i]] - '0';//移动方向
                 
                            int ox = robot[robot_index].x;//当前x坐标
                            int oy = robot[robot_index].y;

                            int mx = robot[robot_index].x + dx[direc];//目标x坐标
                            int my = robot[robot_index].y + dy[direc];//目标y坐标
                            if (rb[mx][my] == 'A') {
                                block_time[i]++;
                                if (block_time[i] > 5) {
                                    //重新规划路线
                                    int temp = robcnt;//保护现场
                                    robcnt = i;
                                    bfs3(ox,oy);//重新规划路线
                                    robcnt = temp;//恢复现场
                                    if (flag3 == 1) {
                                        steped3[i] = 0;//重置步数
                                        block_time[i] = 0;//重置阻塞时间
                                        
                                        printf("move %d %d\n", robot_index, path3[i][steped3[i]] - '0');
 

                                        rb[robot[robot_index].x + dx[direc]][robot[robot_index].y + dy[direc]] = 'A';//预更新地图
                                        steped3[i]++;//下一步

                                    }
                                    else {
                                        fprintf(file, "应该都能找到路线才对，不应进入else分支\n");
                                        //只好任务中断
                                        robing[i] = -1;
                                        rob_task[robot_index] = -1;//机器人空闲

                 
                                        printf("pull %d\n", robot_index);
                                        //fprintf(file, "任务中断, pull %d\n", robot_index);
                                        //hd[ox][oy] = '1';//货物计时重置
                                      

                                    }

                                    
                                   
                                }
                                continue;
                            }
                            else {
                                block_time[i] = 0;
                                printf("move %d %d\n", robot_index, direc);
                                //fprintf(file, "To berth: move %d %d\n", robot_index, direc);
                               
                                rb[mx][my] = 'A';//预更新地图
                                steped3[i]++;//下一步
                            }
                            
                            
                        }

                    }

                }
            }
            
            //=====输出船舶指令

         
            if (id>40) {
                //剩余时间
                int remain_time = 15000 - id-10;//10帧容错
                for (int i = 0; i < boat_num; ++i) {//统计哪些船有任务在身
                    if (boat[i].pos == -1 && boat[i].status != 0) {//当前船在虚拟点闲置
                        boat[i].num = 0;//货物量清零
                        taskboat[i] = 0;//等待分配任务
                    }
       
                    
                }

                for (int i = 0; i < berth_num; ++i) {//i为泊点编号
                    if (bercnt[i] > 0) {//当前泊点有货物
                        int boat_index = berboat[i];//当前泊点的船的编号，没船则为-1
                        if (boat_index != -1) {//当前泊点已经有停靠的船
                            if (reach_fps[boat_index] == -1) {
                                reach_fps[boat_index] = id;//记录到达时间
                                continue;
                            }
                            fprintf(file, "船舶到达泊点 %d 的帧数为 %d ,此时泊点货物量为 %d\n", i, reach_fps[boat_index], bercnt[i]);
                            
                            int curload = (id - 1 - reach_fps[boat_index]) * berth[i].loading_speed;//已装载的货物量(容错/多等1帧)

                            //剩余时间不够了，直接出发
                            if (berth[i].transport_time >= remain_time) {
                                fprintf(file, "go %d\n", boat_index);
                                printf("go %d\n", boat_index);//直接出发
                                taskbert[i] = -1;//泊点释放，等待新船到来
                                berboat[i] = -1;//当前泊点没有船停靠了
                                bercnt[i] -= min(bercnt[i],curload);//货物运走
                                taskboat[boat_index] = 1;//给船舶分配任务
                                reach_fps[boat_index] = -1;//重置到达时间
                                continue;
                            }

                            if (curload >= boat_capacity-boat[boat_index].num && curload<=bercnt[i]) {//货物装载完毕-船舶装满
                               
                                fprintf(file, "go %d\n", boat_index);
                                printf("go %d\n", boat_index);//直接出发
                                taskbert[i] = -1;//泊点释放，等待新船到来
                                berboat[i] = -1;//当前泊点没有船停靠了
                                bercnt[i] -= (boat_capacity - boat[boat_index].num);//货物运走
                                taskboat[boat_index] = 1;//给船舶分配任务
                                reach_fps[boat_index] = -1;//重置到达时间
                            }
                            else if (curload >= bercnt[i]&&curload<=(boat_capacity - boat[boat_index].num)) {//货物装载完毕-货物装完
                                boat[boat_index].num += bercnt[i];//船舶装了一部分货物
                                bercnt[i] = 0;//货物运走
                                fprintf(file, "泊点 %d 的货物装完，船舶剩余容量 %d\n", i, boat_capacity - boat[boat_index].num);
                                if (berth[i].transport_time <= 250) {
                                    fprintf(file, "泊点 %d 的运输时间短，直接go\n", i);
                                    fprintf(file, "go %d\n", boat_index);
                                    printf("go %d\n", boat_index);//直接出发
                                    taskbert[i] = -1;//泊点释放，等待新船到来
                                    berboat[i] = -1;//当前泊点没有船停靠了

                                    taskboat[boat_index] = 1;//给船舶分配任务
                                    reach_fps[boat_index] = -1;//重置到达时间
                                    continue;
                                }
                                fprintf(file, "尝试前往其它泊点\n");
                                int index = -1;//泊点编号
                                int num = 1;//货物量
                                for (int j = 0; j < berth_num; ++j) {//前往其它泊点
                                    
                                    if (bercnt[j] > 0&& berboat[j]==-1&&taskbert[j]==-1) {//该泊点没有船过来，也没有船停靠
                                        if (bercnt[j] > num) {//寻找货物量最多的港口（之后可以优化为价值最高的港口）
                                            index = j;
                                            num = bercnt[j];
                                        }
                                    }
                                }
                                //先把此刻所在的泊点信息重置
                                taskbert[i] = -1;//泊点释放，等待新船到来
                                berboat[i] = -1;//当前泊点没有船停靠了
                                
                                taskboat[boat_index] = 1;//给船舶分配任务
                                reach_fps[boat_index] = -1;//重置到达时间
                                
                                if (index != -1&&(500+berth[index].transport_time)<remain_time) {//给当前船舶分配新任务
                                    fprintf(file, "找到目标，泊点 %d 货物数量 %d\n", index,num);
                                  
                                    //前往新泊点
                                    fprintf(file, "前往新泊点 ship %d %d\n", boat_index, index);
                                    printf("ship %d %d\n", boat_index, index);
                                    taskbert[index] = boat_index;//有船正在过来
                                    //oribert[boat_index] = i;//记录出发泊点
                                    continue;
                                }
                                else {//直接出发吧
                                    fprintf(file, "没找到目标/耗时太长，直接出发吧\n");
                                    fprintf(file, "go %d\n", boat_index);
                                    printf("go %d\n", boat_index);//直接出发
                                }

                            }
                        }
                        else if (taskbert[i] != -1) {//有船正在过来，不需要处理
                            continue;
                        }
                        else {//寻找空余的船
                            for (int j = 0; j < boat_num; ++j) {//j为船舶编号
                                if (taskboat[j] == 0) {
                                    taskboat[j] = 1;
                                    fprintf(file, "ship %d %d\n", j, i);
                                    printf("ship %d %d\n", j, i);
                                    fprintf(file, "船舶 %d 分配到泊点 %d\n", j, i);
                                    taskbert[i] = j;//有船正在过来
                                    break;
                                }
                            }
                        }


                    }
                }
            }
           
            


        
        //输出OK，指令发送完毕
        puts("OK");
        fflush(stdout);
        if (id >= 14998) {
            fprintf(file, "money %d\n", money);
            fprintf(file, "robcnt %d\n", robcnt);
   
            fflush(file);
        }
    }

    // 关闭文件  
    fclose(file);
    return 0;
}
